#块列表 = 【
    【
        【1,2,1】
        【1,2,1】
        【1,2,1】
    】，
    【
        【3,3】
        【3,3】
    】，
    【
        【4,4,1】
        【0,4,4】
        【0,1,1】
    】，
    【
        【1,5,5】
        【5,5,1】
        【0,0,1】
    】，
    【
        【6,6,6】
        【0,6,1】
        【0,0,1】
    】，
    【
        【1,7,1】
        【1,7,1】
        【1,7,7】
    】，
    【
        【0,8,1】
        【1,8,1】
        【8,8,1】
    】，
】

#窗 = @生成图形、《窗口 #宽=400，#高=440，#标题=“俄罗斯方块” 【
    《面板 #名=“#主面板”，#宽=220，#高=400，#X=0，#Y=0，#背景色=“#EEEEEE”》
    《文本标签 #文本=“下一块”，#X=270，#Y=40，#字号=22》
    《面板 #名=“#预览面板”，#宽=80，#高=80，#X=270，#Y=75》
    
    《文本标签 #文本=“得分”，#X=270，#Y=240，#字号=22》
    《文本标签 #名=“#得分标签” #文本=“0”，#X=270，#Y=270，#字号=18》
    
    《按钮 #名=“#重新开始按钮” #文本=“重新开始”，#X=270，#Y=320，#字号=15，#可见=“隐藏”》
】》

#运行中 = 真
#得分 = 0
#单元矩阵 = 【】

@取颜色 = @【#状态】｛
    如果 #状态 等于 2｛
        返回 “#666”
    ｝再则 #状态 等于 3｛
        返回 “#3366cc”
    ｝再则 #状态 等于 4｛
        返回 “#006633”
    ｝再则 #状态 等于 5｛
        返回 “#993333”
    ｝再则 #状态 等于 6｛
        返回 “#cc33ff”
    ｝再则 #状态 等于 7｛
        返回 “#ff9966”
    ｝再则 #状态 等于 8｛
        返回 “#FF82AB”
    ｝否则｛
       返回 “#666”
    ｝
｝

当 #行：0，#行 小于 20，#行 自加 1 ｛
    #行集合：【】
    当 #列：0，#列 小于 11，#列 自加 1 ｛
        #单元：@生成图形、《面板 #宽=20，#高=20，#X=#列*20，#Y=#行*20，#状态=0，#位置=【#行，#列】》 
        @追加【#行集合，#单元】
    ｝
    #主面板@加子集、#行集合
    @追加【#单元矩阵，#行集合】
｝

#预览矩阵 = 【】
当 #行：0，#行 小于 4，#行 自加 1｛
    #行集合：【】
    当 #列：0，#列 小于 4，#列 自加 1｛
        #单元：@生成图形、《面板 #宽=20，#高=20，#X=#列*20，#Y=#行*20，#状态=0》 
        @追加【#行集合，#单元】
    ｝
    #预览面板@加子集、#行集合
    @追加【#预览矩阵，#行集合】
｝

@显示窗口、#窗

#当前行：0
#当前列：5
#当前块： 【
    【1,2,1】
    【1,2,1】
    【1,2,1】
】
#下一块：#块列表#【#数学库@随机数、@取长度【#块列表】】

@渲染单元 = @【#单元，#状态】｛
    #单元#状态 = #状态
    #单元#背景色 = @取颜色【#状态】
    #单元#边框宽 = 1
    #单元#边框色 = “White” 
｝

@清空单元 = @【#单元】｛
   #单元#状态 = 0
   #单元#背景色 = “Transparent”
   #单元#边框宽 = 0
｝

@加新块 = @【】｛
    当 #行：0，#行 小于 @取长度【#当前块】，#行 自加 1 ｛
        当 #列：0，#列 小于 @取长度【#当前块#0】，#列 自加 1｛
            如果 #当前块#行#列 大于 1 ｛
               #单元 ： #单元矩阵#【#当前行+#行】#【#当前列+#列】
                如果 #单元#状态 大于 0｛
                    #运行中 = 假
                    #重新开始按钮#可见=“显示”
                ｝
               @渲染单元【#单元，#当前块#行#列】          
            ｝
        ｝
    ｝
｝
@预览下一块 = @【】｛
    当 #行：0，#行 小于 4，#行 自加 1 ｛
        当 #列：0，#列 小于 4，#列 自加 1｛
            #单元 ： #预览矩阵#行#列
            如果 #行 大于等于 @取长度【#下一块】 或 #列 大于等于 @取长度【#下一块#0】｛
                @清空单元、#单元
                继续
            ｝
        
            如果 #下一块#行#列 大于 1 ｛
               @渲染单元【#单元，#下一块#行#列】          
            ｝否则｛
                @清空单元、#单元
            ｝
        ｝
    ｝
｝

@加新块【】
@预览下一块【】

@判断越界 = @【#行，#列】｛
    返回 #行 小于 0 或 #行 大于等于 20 或 #列 小于 0 或 #列 大于等于 11
｝

@判断重叠 = @【#记录行，#记录列】｛
    #哈希集：@创建哈希集【】
    当 #行：0，#行 小于 @取长度【#当前块】，#行 自加 1｛
        当 #列：0，#列 小于 @取长度【#当前块#0】，#列 自加 1｛
            如果 #当前块#行#列 大于 1｛
                #哈希集@添加、#单元矩阵#【#当前行+#行】#【#当前列+#列】
            ｝
        ｝
    ｝

    当 #行：0，#行 小于 @取长度【#当前块】，#行 自加 1 ｛
        当 #列：0，#列 小于 @取长度【#当前块#0】，#列 自加 1｛
            如果 @判断越界【#记录行+#行，#记录列+#列】 ｛ 
                如果 #当前块#行#列 大于 1 ｛
                   返回 真
                ｝否则｛
                    继续
                ｝
            ｝再则 #当前块#行#列 大于 1 且 #单元矩阵#【#记录行+#行】#【#记录列+#列】#状态 大于 1｛
                如果 取反 #哈希集@包含、#单元矩阵#【#记录行+#行】#【#记录列+#列】｛
                    返回 真
                ｝
            ｝
        ｝
    ｝
    返回 假
｝

@移动块 = @【#行数，#列数】｛
    #哈希集 ： @创建哈希集【】
    当 #行：0，#行 小于 @取长度【#当前块】，#行 自加 1｛
        当 #列：0，#列 小于 @取长度【#当前块#0】，#列 自加 1 ｛
            如果 #当前块#行#列 大于 1 ｛
                #单元：#单元矩阵#【#当前行+#行+#行数】#【#当前列+#列+#列数】
                @渲染单元【#单元，#当前块#行#列】
                #哈希集@添加、#单元   
            ｝
        ｝
    ｝
    当 #行：0，#行 小于 @取长度【#当前块】，#行 自加 1｛
        当 #列：0，#列 小于 @取长度【#当前块#0】，#列 自加 1 ｛
            如果 #当前块#行#列 大于 1 ｛
                #单元：#单元矩阵#【#当前行+#行】#【#当前列+#列】
                如果 取反 #哈希集@包含【#单元】｛
                    @清空单元、#单元
                ｝  
            ｝
        ｝
    ｝
｝

@旋转块 = @【】｛
    #临时 ： 【】
    当 #列：0，#列 小于 @取长度【#当前块#0】，#列 自加 1｛
        @追加【#临时，【】】
    ｝

    当 #行：0，#行 小于 @取长度【#当前块】，#行 自加 1｛
        当 #列：0，#列 小于 @取长度【#当前块#0】，#列 自加 1｛
            @插入【#临时#列，0，#当前块#行#列】
        ｝
    ｝

    当 #行：0，#行 小于 @取长度【#临时】，#行 自加 1｛
        当 #列：0，#列 小于 @取长度【#临时#0】，#列 自加 1｛
            如果 @判断越界【#当前行+#行，#当前列+#列】  ｛
                如果 #临时#行#列 大于 1 ｛
                    返回 空
                ｝  
            ｝再则 #临时#行#列 大于 0 且 #当前块#行#列 小于 2 且 #单元矩阵#【#当前行+#行】#【#当前列+#列】#状态 大于 0 ｛
                返回 空
            ｝
        ｝
    ｝
    
    当 #行：0，#行 小于 @取长度【#临时】，#行 自加 1｛
        当 #列：0，#列 小于 @取长度【#临时#0】，#列 自加 1｛
            如果 取反 @判断越界【#当前行+#行，#当前列+#列】 ｛
                #单元 ： #单元矩阵#【#当前行+#行】#【#当前列+#列】
                如果 #临时#行#列 大于 1｛
                    @渲染单元【#单元，#临时#行#列】
                ｝否则｛
                    如果 #当前块#行#列 大于 1｛
                        @清空单元、#单元
                    ｝ 
                ｝
            ｝
        ｝
    ｝
    #当前块 = #临时
｝

#下一按键 = “”
#时序 = 1
#界面更新中 = 假
#刷新间隔 = 25

#窗@键盘按下命令 = @【#按键】｛
    如果 #按键 等于 “Down”｛
        #刷新间隔 = 2
        返回 空
    ｝
    #下一按键 = #按键
｝

#窗@键盘放开命令 = @【#按键】｛
    如果 #按键 等于 “Down”｛
        #刷新间隔 = 25
    ｝
｝

@判断得分 = @【】｛
    #满行数：0
    #记录矩阵：【】  
    当 #行：0，#行 小于 @取长度【#单元矩阵】，#行 自加 1｛
        #已满：真
        #记录行：【】
        当 #列：0，#列 小于 @取长度【#单元矩阵#行】，#列 自加 1｛
            @追加【#记录行，#单元矩阵#行#列#状态】
            如果 #单元矩阵#行#列#状态 等于 0｛
                #已满 = 假 
            ｝
        ｝
        如果 取反 #已满｛
            @追加【#记录矩阵，#记录行】
        ｝否则｛
            #满行数 自加 1
        ｝
    ｝
    #行差：@取长度【#单元矩阵】 - @取长度【#记录矩阵】
    
    当 #行：0，#行 小于 @取长度【#单元矩阵】，#行 自加 1｛
        当 #列：0，#列 小于 @取长度【#单元矩阵#行】，#列 自加 1｛
            如果 #行 小于 #行差｛
                @清空单元、#单元矩阵#行#列
            ｝否则｛
                #记录 ： #记录矩阵#【#行-#行差】#列
                如果 #记录 大于 0｛
                    @渲染单元【#单元矩阵#行#列，#记录】
                ｝否则｛
                    @清空单元、#单元矩阵#行#列
                ｝
            ｝
        ｝
    ｝
    如果 #满行数 大于 0｛
        如果 #满行数 等于 2｛
            #得分 自加 3
        ｝再则 #满行数 等于 3｛
            #得分 自加 5
        ｝否则｛
            #得分 自加 1
        ｝
        #得分标签#文本 = “” + #得分
    ｝
｝

#重新开始按钮@命令 = @【】｛
    #得分 = 0
    #得分标签#文本 = “0”
    当 #行：0，#行 小于 20，#行 自加 1｛
        当 #列：0，#列 小于 11，#列 自加 1｛
            #单元矩阵#行#列#状态 = 0
            @清空单元、#单元矩阵#行#列
        ｝
    ｝
    #当前行 = 0
    #当前列 = 5
    #当前块 = #块列表#【#数学库@随机数、@取长度【#块列表】】
    #下一块 = #块列表#【#数学库@随机数、@取长度【#块列表】】
    @加新块【】
    @预览下一块【】
    #运行中 = 真
    #重新开始按钮#可见=“隐藏”
｝


#定时器 = @定时任务【20，｛
    如果 取反 #运行中 ｛ 返回 空 ｝
    如果 #界面更新中 ｛ 返回 空 ｝
    #界面更新中 = 真
    #时序 = （#时序 + 1） % #刷新间隔
    如果 #下一按键 等于 “Left”｛
        如果 取反 @判断重叠【#当前行，#当前列-1】｛
            @移动块【0，-1】
            #当前列 自减 1
        ｝
    ｝
    如果 #下一按键 等于 “Right”｛
        如果 取反 @判断重叠【#当前行，#当前列+1】｛
            @移动块【0，1】
            #当前列 自加 1
        ｝
    ｝
    如果 #下一按键 等于 “Up”｛
        @旋转块【】
    ｝
    #下一按键 = “”
    如果 #时序 等于 0｛
        如果 @判断重叠【#当前行+1，#当前列】｛
           @判断得分【】
           #当前行 = 0
           #当前列 = 5
           #当前块 = #下一块
           #下一块 = #块列表#【#数学库@随机数、@取长度【#块列表】】
           @加新块【】
           @预览下一块【】
        ｝否则｛
           @移动块【1,0】
           #当前行 自加 1
        ｝ 
    ｝

    #界面更新中 = 假
    
｝】

@启动定时任务、#定时器













